home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 May / macformat-024.iso / Shareware City / Developers / Kant Pro source Folder / Kant Pro 1.1 ƒ / Shell ƒ / resource utilities.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-21  |  4.3 KB  |  181 lines  |  [TEXT/MMCC]
  1. #include "resource utilities.h"
  2. #include "util.h"
  3.  
  4. OSErr OpenTheResFile(FSSpec* fs, short* oldRefNum, short* newRefNum, Boolean* alreadyOpen,
  5.     Boolean readOnly)
  6. {
  7.     Handle            oldTopMapHndl;
  8.     OSErr            theResError;
  9.     
  10.     *oldRefNum=CurResFile();
  11.     oldTopMapHndl=LMGetTopMapHndl();
  12.     *newRefNum=HOpenResFile(fs->vRefNum, fs->parID, fs->name, readOnly ? fsRdPerm : fsRdWrPerm);
  13.     theResError=ResError();
  14.     *alreadyOpen=(oldTopMapHndl==LMGetTopMapHndl());
  15.     if (theResError==noErr)
  16.         UseResFile(*newRefNum);
  17.     return theResError;
  18. }
  19.  
  20. void CloseTheResFile(short oldRefNum, short newRefNum, Boolean alreadyOpen)
  21. {
  22.     if (!alreadyOpen)
  23.     {
  24.         CloseResFile(newRefNum);
  25.     }
  26.     UseResFile(oldRefNum);
  27. }
  28.  
  29. Handle SafeReleaseResource(Handle resHandle)
  30. {
  31.     if (resHandle!=0L)
  32.         ReleaseResource(resHandle);
  33.     
  34.     return 0L;
  35. }
  36.  
  37. OSErr AddIndString(StringPtr theStr, short resID)
  38. /* adds new indexed string to end of STR# resource */
  39. {
  40.     Handle            resHandle;
  41.     OSErr            oe;
  42.     long            oldResSize;
  43.     
  44.     resHandle=Get1Resource('STR#', resID);
  45.     if ((oe=ResError())!=noErr)
  46.         return oe;
  47.     
  48.     oldResSize=GetHandleSize(resHandle);
  49.     SetHandleSize(resHandle, oldResSize+theStr[0]+1);
  50.     if ((oe=MemError())!=noErr)
  51.     {
  52.         ReleaseResource(resHandle);
  53.         return oe;
  54.     }
  55.     
  56.     HLock(resHandle);
  57.     Mymemcpy((Ptr)((unsigned long)*resHandle+oldResSize), (Ptr)theStr, theStr[0]+1);
  58.     (**((short**)resHandle))++;
  59.     
  60.     ChangedResource(resHandle);
  61.     WriteResource(resHandle);
  62.     HPurge(resHandle);
  63.     ReleaseResource(resHandle);
  64.  
  65.    return ResError();
  66. }
  67.  
  68. OSErr DeleteIndString(short resID, short index)
  69. {
  70.     Handle            resHandle;
  71.     OSErr            oe;
  72.     unsigned long    oldResSize;
  73.     unsigned long    offset;
  74.     unsigned char    *stringPtr;
  75.     short            i;
  76.     unsigned short    stringLength;
  77.     
  78.     resHandle=Get1Resource('STR#', resID);
  79.     if ((oe=ResError())!=noErr)
  80.         return oe;
  81.     
  82.     HLock(resHandle);
  83.     HNoPurge(resHandle);
  84.     
  85.     (**((short**)resHandle))--;
  86.     
  87.     oldResSize=GetHandleSize(resHandle);
  88.     offset=sizeof(short);
  89.     stringPtr=(unsigned char*)*resHandle+offset;
  90.     for (i=1; i<index; i++)
  91.     {
  92.         offset+=1+stringPtr[0];
  93.         stringPtr+=1+stringPtr[0];
  94.     }
  95.     
  96.     stringLength=stringPtr[0]+1;
  97.     Mymemcpy((Ptr)stringPtr, (Ptr)((unsigned long)stringPtr+stringPtr[0]+1), oldResSize-offset);
  98.     SetHandleSize(resHandle, oldResSize-stringLength);
  99.     
  100.     ChangedResource(resHandle);
  101.     WriteResource(resHandle);
  102.     HPurge(resHandle);
  103.     ReleaseResource(resHandle);
  104.     
  105.     return ResError();
  106. }
  107.  
  108. // the following is based on a snippet from Apple
  109. OSErr SetIndString(StringPtr theStr,short resID,short strIndex)
  110. {
  111.    Handle theRes;               /* handle pointing to STR# resource */
  112.    unsigned short numStrings;            /* number of strings in STR# */
  113.    unsigned short ourString;             /* counter to index up to strIndex */
  114.    unsigned char *resStr;                /* string pointer to STR# string to replace */
  115.    unsigned long oldSize;                /* size of STR# resource before call */
  116.    unsigned long newSize;                /* size of STR# resource after call */
  117.    unsigned long offset;        /* resource offset to str to replace*/
  118.  
  119.    /* make sure index is in bounds */
  120.  
  121.    if (resID < 1)
  122.    return -1;
  123.  
  124.    /* make sure resource exists */
  125.  
  126.    theRes = Get1Resource('STR#',resID);
  127.    if (ResError()!=noErr)
  128.    return ResError();
  129.    if (!theRes || !(*theRes))
  130.    return resNotFound;
  131.  
  132.    HLock(theRes);
  133.    HNoPurge(theRes);
  134.  
  135.    /* get # of strings in STR# */
  136.  
  137.    BlockMove(*theRes,&numStrings,sizeof(short));
  138.    if (strIndex > numStrings)
  139.    return resNotFound;
  140.  
  141.    /* get a pointer to the string to replace */
  142.  
  143.    offset = sizeof(short);
  144.    resStr = (unsigned char *) *theRes + sizeof(short);
  145.    for (ourString=1; ourString<strIndex; ourString++) {
  146.    offset += 1+resStr[0];
  147.    resStr += 1+resStr[0];
  148.    }
  149.  
  150.    /* grow/shrink resource handle to make room for new string */
  151.  
  152.    oldSize = GetHandleSize(theRes);
  153.    newSize = oldSize - resStr[0] + theStr[0];
  154.    HUnlock(theRes);
  155.    SetHandleSize(theRes,newSize);
  156.    if (MemError()!=noErr)
  157.    {
  158.        ReleaseResource(theRes);
  159.        return MemError();
  160.    }
  161.    HLock(theRes);
  162.    resStr = (unsigned char*)((unsigned long)*theRes + offset);
  163.  
  164.    /* move old data forward/backward to make room */
  165.  
  166.    BlockMove(resStr+resStr[0]+1, resStr+theStr[0]+1, oldSize-offset-resStr[0]-1);
  167.  
  168.    /* move new data in */
  169.  
  170.    BlockMove(theStr,resStr,theStr[0]+1);
  171.  
  172.    /* write resource out */
  173.  
  174.    ChangedResource(theRes);
  175.    WriteResource(theRes);
  176.    HPurge(theRes);
  177.    ReleaseResource(theRes);
  178.  
  179.    return ResError();
  180. }
  181.